{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright 2021 The TensorFlow Similarity Authors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# @title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "# https://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TensorFlow Similarity Self-Supervised Learning Hello World"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/similarity/blob/master/examples/unsupervised_hello_world.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://github.com/tensorflow/similarity/blob/master/examples/unsupervised_hello_world.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[TensorFlow Similarity](https://github.com/tensorflow/similarity) is a python package focused on making similarity learning and self-supervised learning quick and easy.\n",
    "\n",
    "![self_supervised_overview.png](https://raw.githubusercontent.com/tensorflow/similarity/master/assets/images/self_supervised_overview.png)\n",
    "\n",
    "Self-supervised learning is an approach to pre-training models using unlabeled data. This approach drastically increases accuracy when you have very few labeled examples but a lot of unlabelled data. The key insight is that you can train a self-supervised model to learn data representations by contrasting multiple augmented views of the same example. These learned representations capture data invariants, e.g., object translation, color jitter, noise, etc. Training a simple linear classifier on top of the frozen representations is easier and requires fewer labels because the pre-trained model already produces meaningful and generally useful features. Overall, self-supervised pre-training learns representations which are more [generic](https://arxiv.org/abs/2110.00528) and [robust](https://arxiv.org/abs/1902.01889) than other approaches to augmented training and pre-training. \n",
    "\n",
    "Tensorflow Similarity provides a set of network architectures, losses, and data augmentations that are common across a number of self-supervised learning techniques. The Tensorflow Similarity package attempts to provide a consistent terminology across these techniques; however, this leads to slightly different naming conventions, as many papers use different terms to describe the same components. \n",
    "\n",
    "The main terms used by Tensorflow Similarity are:\n",
    "\n",
    "* **View**: A view represents an augmented example.\n",
    "\n",
    "* **Backbone**: Refers to the model that learns the **Representation** that we will use for downstream tasks.\n",
    "\n",
    "* **Projector**: Is an MLP model that projects the backbone representation of a view to an **Embedding** that is contrasted with other views using a specialized contrastive loss.\n",
    "\n",
    "* **Predictor**: Is an optional MLP model that is used, in conjunction with gradient stopping, in some recent architectures to further improve the representation quality.\n",
    "\n",
    "* **Stop Gradient**: Is used by some algorithms to ensure that we only propagate the update from the main view and not the contrasting view.\n",
    "\n",
    "\n",
    "![contrastive_model_terms.png](https://raw.githubusercontent.com/tensorflow/similarity/master/assets/images/contrastive_model_terms.png)\n",
    "\n",
    "\n",
    "### Notebook goal\n",
    "\n",
    "This notebook demonstrates how to use Tensorflow Similarity to boost classification accuracy by pre-training a ResNet18 model using contrastive learning on the cifar10 dataset. As you will see, the pre-trained model achieves about ~1.8x the accuracy of the model trained without pre-training. For example, **using SimSiam pre-training, you can achieve 87%-91% accuracy versus 50% accuracy when training the same architecture from scratch**.\n",
    "\n",
    "To do this, this notebook walks through how to:\n",
    "\n",
    "1. Create a `tf.data.Dataset` that will generate two augmented views for each example in a batch.\n",
    "\n",
    "2. Create basic versions of **Backbone**, **Projector**, and **Predictor** networks to construct the `ContrastiveModel()`\n",
    "\n",
    "3. Train a `ContrastiveModel()` using one of the following contrastive learning algorithms: [SimCLR](https://arxiv.org/abs/2002.05709), [SimSiam](https://arxiv.org/abs/2011.10566), and [Barlow Twins](https://arxiv.org/abs/2103.03230).\n",
    "\n",
    "4. Compare the classification performance of the pre-trained model versus a model trained from scratch.\n",
    "\n",
    "\n",
    "### Things to try\n",
    "\n",
    "You can explore the following things that will affect the model performance:\n",
    "- Try different self-supervised learning algorithms.\n",
    "- Pre-train on a different dataset, e.g., cifar100.\n",
    "- Restrict supervised training to use a subset of the data, e.g., 100 labels per class.\n",
    "- Use a larger embedding by increasing the size of the projection and predictor layers.\n",
    "- Try using different augmentation profiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gc\n",
    "import os\n",
    "import random\n",
    "import time\n",
    "from pathlib import Path\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from tabulate import tabulate\n",
    "\n",
    "# INFO messages are not printed.\n",
    "# This must be run before loading other modules.\n",
    "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/dist-packages/tensorflow_addons/utils/ensure_tf_install.py:53: UserWarning: Tensorflow Addons supports using Python ops for all Tensorflow versions above or equal to 2.9.0 and strictly below 2.12.0 (nightly versions are not supported). \n",
      " The versions of TensorFlow you are currently using is 2.12.0 and is not supported. \n",
      "Some things might work, some things might not.\n",
      "If you were to encounter a bug, do not file an issue.\n",
      "If you want to make sure you're using a tested and supported configuration, either change the TensorFlow version or the TensorFlow Addons's version. \n",
      "You can find the compatibility matrix in TensorFlow Addon's readme:\n",
      "https://github.com/tensorflow/addons\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# install TF addons if needed\n",
    "try:\n",
    "    import tensorflow_addons as tfa  # main package\n",
    "except ModuleNotFoundError:\n",
    "    %pip install tensorflow-addons\n",
    "    import tensorflow_addons as tfa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# install TF similarity if needed\n",
    "try:\n",
    "    import tensorflow_similarity as tfsim  # main package\n",
    "except ModuleNotFoundError:\n",
    "    %pip install tensorflow_similarity\n",
    "    import tensorflow_similarity as tfsim\n",
    "import tensorflow_similarity.visualization as tfsim_visualization\n",
    "import tensorflow_similarity.callbacks as tfsim_callbacks\n",
    "import tensorflow_similarity.augmenters as tfsim_augmenters\n",
    "import tensorflow_similarity.losses as tfsim_losses\n",
    "import tensorflow_similarity.architectures as tfsim_architectures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "import tensorflow_datasets as tfds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "tfsim.utils.tf_cap_memory()  # Avoid GPU memory blow up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clear out any old model state.\n",
    "gc.collect()\n",
    "tf.keras.backend.clear_session()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorFlow: 2.12.0\n",
      "TensorFlow Similarity 0.18.0.dev8\n"
     ]
    }
   ],
   "source": [
    "print(\"TensorFlow:\", tf.__version__)\n",
    "print(\"TensorFlow Similarity\", tfsim.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset Preperation\n",
    "\n",
    "The following section:\n",
    "* Loads the [CIFAR10](https://www.tensorflow.org/datasets/catalog/cifar10) data from tensorflow datasets.\n",
    "* Creates the train, val, test, and query/index splits."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_PATH = Path(\"tfsim_contrastive_model\")\n",
    "if not DATA_PATH.exists():\n",
    "    DATA_PATH.mkdir(parents=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Load The Raw Data\n",
    "\n",
    "We are going to load the [CIFAR10](https://www.tensorflow.org/datasets/catalog/cifar10) dataset. This dataset is often used in the self-supervised papers, enabling us to reproduce the published results. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "((x_raw_train, y_raw_train), (x_test, y_test)), ds_info = tfds.load(\n",
    "    \"cifar10\",\n",
    "    split=[\"train\", \"test\"],\n",
    "    batch_size=-1,\n",
    "    shuffle_files=True,\n",
    "    as_supervised=True,\n",
    "    with_info=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Data Splits\n",
    "The TensorFlow Datasets' [CIFAR10](https://www.tensorflow.org/datasets/catalog/cifar10) dataset provides a test and train split. \n",
    "* **Train**: Used for self-supervised pre-training and for training the classifiers.\n",
    "* **Test**: Reserved for the classifier evaluation.\n",
    "\n",
    "However, we are going to partition the train data into the following additional splits:\n",
    "\n",
    "* **Validation**: Data used for validation metrics during the pre-training phase. \n",
    "* **Query and Index**: Data used to compute matching metrics. The query data is used to retrieve the nearest indexed examples.\n",
    "\n",
    "In particular, the Query and Index split allows us to track the matching classification performance during training. \n",
    "\n",
    "<div class=\"alert alert-block alert-info\"> <b>NOTE </b> An increasing match accuracy is a strong indication that the model is learning useful features, however, it does require that we have labeled data. If a dataset only has a small number of labeled examples, they can be passed as the query and index to help monitor the potential matching classification performance during training.</div> \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute the indicies for query, index, val, and train splits\n",
    "query_idxs, index_idxs, val_idxs, train_idxs = [], [], [], []\n",
    "for cid in range(ds_info.features[\"label\"].num_classes):\n",
    "    idxs = tf.random.shuffle(tf.where(y_raw_train == cid))\n",
    "    idxs = tf.reshape(idxs, (-1,))\n",
    "    query_idxs.extend(idxs[:200])  # 200 query examples per class\n",
    "    index_idxs.extend(idxs[200:400])  # 200 index examples per class\n",
    "    val_idxs.extend(idxs[400:500])  # 100 validation examples per class\n",
    "    train_idxs.extend(idxs[500:])  # The remaining are used for training\n",
    "\n",
    "random.shuffle(query_idxs)\n",
    "random.shuffle(index_idxs)\n",
    "random.shuffle(val_idxs)\n",
    "random.shuffle(train_idxs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_split(idxs: list) -> tuple:\n",
    "    x, y = [], []\n",
    "    for idx in idxs:\n",
    "        x.append(x_raw_train[int(idx)])\n",
    "        y.append(y_raw_train[int(idx)])\n",
    "    return tf.convert_to_tensor(np.array(x)), tf.convert_to_tensor(np.array(y))\n",
    "\n",
    "\n",
    "x_query, y_query = create_split(query_idxs)\n",
    "x_index, y_index = create_split(index_idxs)\n",
    "x_val, y_val = create_split(val_idxs)\n",
    "x_train, y_train = create_split(train_idxs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Examples            Labels\n",
      "-----  ------------------  --------\n",
      "train  (45000, 32, 32, 3)  (45000,)\n",
      "val    (1000, 32, 32, 3)   (1000,)\n",
      "query  (2000, 32, 32, 3)   (2000,)\n",
      "index  (2000, 32, 32, 3)   (2000,)\n",
      "test   (10000, 32, 32, 3)  (10000,)\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    tabulate(\n",
    "        [\n",
    "            [\"train\", x_train.shape, y_train.shape],\n",
    "            [\"val\", x_val.shape, y_val.shape],\n",
    "            [\"query\", x_query.shape, y_query.shape],\n",
    "            [\"index\", x_index.shape, y_index.shape],\n",
    "            [\"test\", x_test.shape, y_test.shape],\n",
    "        ],\n",
    "        headers=[\"Examples\", \"Labels\"],\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self-Supervised Training Setup\n",
    "\n",
    "This following section:\n",
    "* Sets the training parameters used for building the different architectures.\n",
    "* Creates a train and test tf.data.Dataset.\n",
    "* Visualizes the pairs of augmented views from a single batch."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Self-Supervised Algorithm Selection\n",
    "[TensorFlow Similarity](https://github.com/tensorflow/similarity) currently supports three different self-supervised models.\n",
    "* [SimCLR](http://arxiv.org/abs/2002.05709): Only requires the Backbone and the projector and uses a contrastive cross-entropy loss.\n",
    "* [SimSiam](https://arxiv.org/abs/2011.10566): Requires the Backbone, projector, and predictor and only compares the cosine distance between augmented views from the same example.\n",
    "* [Barlow Twins](https://arxiv.org/abs/2103.03230): Only requires the Backbone and the projector and uses a loss that compares the feature covariance instead of contrasting the views.\n",
    "* [VicReg](https://arxiv.org/abs/2105.04906): Only requires the Backbone and projector and uses a loss that enforces the learned representations to be invariant to random augmentations while preserving the covariance and variance information.\n",
    "\n",
    "The `ALGORITHM` parameter is used throughout this notebook to set up the various architectures and the parameters defined below are set up to reproduce the results published in the papers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "ALGORITHM = \"simsiam\"  # @param [\"barlow\", \"simsiam\", \"simclr\", \"vicreg\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training Parameter Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "CIFAR_IMG_SIZE = 32\n",
    "BATCH_SIZE = 512\n",
    "PRE_TRAIN_EPOCHS = 800\n",
    "PRE_TRAIN_STEPS_PER_EPOCH = len(x_train) // BATCH_SIZE\n",
    "VAL_STEPS_PER_EPOCH = 20\n",
    "WEIGHT_DECAY = 5e-4\n",
    "DIM = 2048  # The layer size for the projector and predictor models.\n",
    "WARMUP_LR = 0.0\n",
    "WARMUP_STEPS = 0\n",
    "TEMPERATURE = None\n",
    "\n",
    "if ALGORITHM == \"simsiam\":\n",
    "    INIT_LR = 3e-2 * int(BATCH_SIZE / 256)\n",
    "elif ALGORITHM == \"barlow\":\n",
    "    INIT_LR = 1e-3  # Initial LR for the learning rate schedule.\n",
    "    WARMUP_STEPS = 1000\n",
    "elif ALGORITHM == \"simclr\":\n",
    "    INIT_LR = 1e-3  # Initial LR for the learning rate schedule, see section B.1 in the paper.\n",
    "    TEMPERATURE = 0.5  # Tuned for CIFAR10, see section B.9 in the paper.\n",
    "elif ALGORITHM == \"vicreg\":\n",
    "    INIT_LR = 1e-3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Augmented View Configuration\n",
    "\n",
    "Self-supervised networks require at least two augmented \"views\" of each example. This can be created using a DataSet and an augmentation function. The DataSet treats each example in the batch as its own class and then the augment function produces two separate views for each example. \n",
    "\n",
    "This means the resulting batch will yield tuples containing the two views, i.e., `Tuple[(BATCH_SIZE, 32, 32, 3), (BATCH_SIZE, 32, 32, 3)]`. TODO make this clearer, \"each example in the batch is of this type\"\n",
    "\n",
    "TensorFlow Similarity provides several random augmentation functions, and here we combine augmenters from the simCLR module to replicate the augmentations used in simsiam."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def img_scaling(img):\n",
    "    return tf.keras.applications.imagenet_utils.preprocess_input(img, data_format=None, mode=\"torch\")\n",
    "\n",
    "\n",
    "@tf.function\n",
    "def simsiam_augmenter(img, blur=True, area_range=(0.2, 1.0)):\n",
    "    \"\"\"SimSiam augmenter.\n",
    "\n",
    "    The SimSiam augmentations are based on the SimCLR augmentations, but have\n",
    "    some important differences.\n",
    "    * The crop area lower bound is 20% instead of 8%.\n",
    "    * The color jitter and grayscale are applied separately instead of together.\n",
    "    * The color jitter ranges are much smaller.\n",
    "    * Blur is not applied for the cifar10 dataset.\n",
    "\n",
    "    args:\n",
    "        img: Single image tensor of shape (H, W, C)\n",
    "        blur: If true, apply blur. Should be disabled for cifar10.\n",
    "        area_range: The upper and lower bound of the random crop percentage.\n",
    "\n",
    "    returns:\n",
    "        A single image tensor of shape (H, W, C) with values between 0.0 and 1.0.\n",
    "    \"\"\"\n",
    "    # random resize and crop. Increase the size before we crop.\n",
    "    img = tfsim.augmenters.augmentation_utils.cropping.crop_and_resize(\n",
    "        img, CIFAR_IMG_SIZE, CIFAR_IMG_SIZE, area_range=area_range\n",
    "    )\n",
    "\n",
    "    # The following transforms expect the data to be [0, 1]\n",
    "    img /= 255.0\n",
    "\n",
    "    # random color jitter\n",
    "    def _jitter_transform(x):\n",
    "        return tfsim.augmenters.augmentation_utils.color_jitter.color_jitter_rand(\n",
    "            x,\n",
    "            np.random.uniform(0.0, 0.4),\n",
    "            np.random.uniform(0.0, 0.4),\n",
    "            np.random.uniform(0.0, 0.4),\n",
    "            np.random.uniform(0.0, 0.1),\n",
    "            \"multiplicative\",\n",
    "        )\n",
    "\n",
    "    img = tfsim.augmenters.augmentation_utils.random_apply.random_apply(_jitter_transform, p=0.8, x=img)\n",
    "\n",
    "    # # random grayscale\n",
    "    def _grascayle_transform(x):\n",
    "        return tfsim.augmenters.augmentation_utils.color_jitter.to_grayscale(x)\n",
    "\n",
    "    img = tfsim.augmenters.augmentation_utils.random_apply.random_apply(_grascayle_transform, p=0.2, x=img)\n",
    "\n",
    "    # optional random gaussian blur\n",
    "    if blur:\n",
    "        img = tfsim.augmenters.augmentation_utils.blur.random_blur(img, p=0.5)\n",
    "\n",
    "    # random horizontal flip\n",
    "    img = tf.image.random_flip_left_right(img)\n",
    "\n",
    "    # scale the data back to [0, 255]\n",
    "    img = img * 255.0\n",
    "    img = tf.clip_by_value(img, 0.0, 255.0)\n",
    "\n",
    "    return img\n",
    "\n",
    "\n",
    "@tf.function()\n",
    "def process(img):\n",
    "    view1 = simsiam_augmenter(img, blur=False)\n",
    "    view1 = img_scaling(view1)\n",
    "    view2 = simsiam_augmenter(img, blur=False)\n",
    "    view2 = img_scaling(view2)\n",
    "    return (view1, view2)\n",
    "\n",
    "\n",
    "train_ds = tf.data.Dataset.from_tensor_slices(x_train)\n",
    "train_ds = train_ds.repeat()\n",
    "train_ds = train_ds.shuffle(1024)\n",
    "train_ds = train_ds.map(process, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "train_ds = train_ds.batch(BATCH_SIZE)\n",
    "train_ds = train_ds.prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "val_ds = tf.data.Dataset.from_tensor_slices(x_val)\n",
    "val_ds = val_ds.repeat()\n",
    "val_ds = val_ds.shuffle(1024)\n",
    "val_ds = val_ds.map(process, num_parallel_calls=tf.data.AUTOTUNE)\n",
    "val_ds = val_ds.batch(BATCH_SIZE)\n",
    "val_ds = val_ds.prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualize Augmentations\n",
    "\n",
    "The following cell plots the pairs of augmented views side by side. This can be a useful sanity check as many augmentation functions are set up for the larger ImageNet examples and can be overly aggressive for smaller images found in CIFAR."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2400x400 with 16 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display_imgs = next(train_ds.as_numpy_iterator())\n",
    "max_pixel = np.max([display_imgs[0].max(), display_imgs[1].max()])\n",
    "min_pixel = np.min([display_imgs[0].min(), display_imgs[1].min()])\n",
    "\n",
    "tfsim_visualization.visualize_views(\n",
    "    views=display_imgs,\n",
    "    num_imgs=16,\n",
    "    views_per_col=8,\n",
    "    max_pixel_value=max_pixel,\n",
    "    min_pixel_value=min_pixel,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Contrastive Model Setup\n",
    " \n",
    "The following section creates the sub-models used by the different algorithms. There are various architectures for building self-supervised models which may include some of the following:\n",
    "* **Backbone**: This is the base model and is typically an existing architecture like ResNet or EfficientNet.\n",
    "* **Projector**: This is a small multi-layer Neural Net and provides the embedding features at the end of training.\n",
    "* **Predictor**: This model is used by BYOL and SimSiam and provides an additional small multi-layer Neural Net.\n",
    " \n",
    "Typically, the projector and predictor networks are only 2 or 3 layers with batch normalization. While some [papers](https://arxiv.org/abs/2010.10241) claim that batch normalization is not required, the [SimSiam paper](https://arxiv.org/abs/2011.10566) shows empirically that the batch normalization is critical to prevent the model from collapsing to a degenerate solution.\n",
    " \n",
    "Additionally, many papers show a single `encoder` block, but this often contains both the `Backbone` and the `Projector` network.\n",
    " \n",
    "![contrastive_loss_functions.png](https://raw.githubusercontent.com/tensorflow/similarity/master/assets/images/contrastive_loss_functions.png)\n",
    " \n",
    "The diagram above shows three self-supervised architectures supported by TensorFlow Similarity. As you can see, they all share a common structure:\n",
    "* Processing multiple views of the same example.\n",
    "* Using a backbone model for learning the representation output. \n",
    "* Using a projector for the embedding output.\n",
    "* Additionally, note that the loss is symmetric, so we compute it twice during each step. First for view 1 and then a second time for view 2. These two losses are then summed up to compute the final aggregate loss.\n",
    " \n",
    "However, there are some key differences including:\n",
    " \n",
    "* The loss is different in each of the three architectures.\n",
    "    * SimCLR uses a contrastive cross-entropy loss where each example's pair of augmented views should be close to 1 and all other views should be close to zero. Including the negative examples in the loss is part of the reason that SimCLR benefits from larger batch sizes.\n",
    "    * SimSiam only compares the cosine distance between the pairs of augmented views. This means there are no negative examples in the loss, and consequently, the batch size can be much smaller.\n",
    "    * Barlow Twins attempts to learn the cross-correlation between the embedding features, where similar feature activations between two views will produce small values along the diagonal and a positive penalty is applied for positive or negative off-diagonal correlations. In this way the diagonal represents features that are invariant to augmented views, while the off-diagonal values encourage the features to be independent of each other.\n",
    "* The SimSiam architecture requires an additional Predictor network.\n",
    "* The SimSiam architecture also uses a stop-gradient to ensure that we only flow the gradient from the target view.\n",
    " \n",
    " \n",
    "TensorFlow Similarity offers a common set of modules to construct the common parts, and implement the parts which are specific to popular self-supervised algorithms on top of it. Attempting to offer flexibility to add your own algorithm or reuse proven architectures that the results we have reproduced. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Backbone Model\n",
    "\n",
    "The backbone uses a custom version of ResNet18 in order to reproduce the SimSiam CIFAR10 results.\n",
    " \n",
    "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> The ResNet models provided in `tf.keras.applications` use larger `[(1x1), (3x3), (1x1)]` blocks that can't be used to reproduce the SimSiam CIFAR10 results. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"resnet18sim\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " input_1 (InputLayer)        [(None, 32, 32, 3)]       0         \n",
      "                                                                 \n",
      " resnet18 (Functional)       (None, 4, 4, 512)         11182784  \n",
      "                                                                 \n",
      " avg_pool (GlobalAveragePool  (None, 512)              0         \n",
      " ing2D)                                                          \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 11,182,784\n",
      "Trainable params: 11,173,056\n",
      "Non-trainable params: 9,728\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "def get_backbone(img_size, activation=\"relu\", preproc_mode=\"torch\"):\n",
    "    input_shape = (img_size, img_size, 3)\n",
    "\n",
    "    backbone = tfsim_architectures.ResNet18Sim(\n",
    "        input_shape,\n",
    "        include_top=False,  # Take the pooling layer as the output.\n",
    "        pooling=\"avg\",\n",
    "    )\n",
    "    return backbone\n",
    "\n",
    "\n",
    "backbone = get_backbone(CIFAR_IMG_SIZE)\n",
    "backbone.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Projector Model\n",
    " \n",
    "This MLP is common to all the self-supervised models and is typically a stack of 3 layers of the same size. However, SimSiam only uses 2 layers for the smaller CIFAR images. Having too much capacity in the models can make it difficult for the loss to stabilize and converge.\n",
    " \n",
    "Additionally, the SimSiam paper found that disabling the center and scale parameters can lead to a small boost in the final loss.\n",
    " \n",
    "<div class=\"alert alert-block alert-info\"> <b>NOTE</b> This is the model output that is returned by `ContrastiveModel.predict()` and represents the distance based embedding. This embedding can be used for the KNN lookups and matching classification metrics. However, when using the pre-train model for downstream tasks, only the `ContrastiveModel.backbone` is used. </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "projector = None  # Passing None will automatically build the default projector.\n",
    "\n",
    "# # Uncomment to build a custom projector.\n",
    "# def get_projector(input_dim, dim, activation=\"relu\", num_layers: int = 3):\n",
    "#     inputs = tf.keras.layers.Input((input_dim,), name=\"projector_input\")\n",
    "#     x = inputs\n",
    "\n",
    "#     for i in range(num_layers - 1):\n",
    "#         x = tf.keras.layers.Dense(\n",
    "#             dim,\n",
    "#             use_bias=False,\n",
    "#             kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#             name=f\"projector_layer_{i}\",\n",
    "#         )(x)\n",
    "#         x = tf.keras.layers.BatchNormalization(epsilon=1.001e-5, name=f\"batch_normalization_{i}\")(x)\n",
    "#         x = tf.keras.layers.Activation(activation, name=f\"{activation}_activation_{i}\")(x)\n",
    "#     x = tf.keras.layers.Dense(\n",
    "#         dim,\n",
    "#         use_bias=False,\n",
    "#         kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#         name=\"projector_output\",\n",
    "#     )(x)\n",
    "#     x = tf.keras.layers.BatchNormalization(\n",
    "#         epsilon=1.001e-5,\n",
    "#         center=False,  # Page:5, Paragraph:2 of SimSiam paper\n",
    "#         scale=False,  # Page:5, Paragraph:2 of SimSiam paper\n",
    "#         name=f\"batch_normalization_ouput\",\n",
    "#     )(x)\n",
    "#     # Metric Logging layer. Monitors the std of the layer activations.\n",
    "#     # Degnerate solutions colapse to 0 while valid solutions will move\n",
    "#     # towards something like 0.0220. The actual number will depend on the layer size.\n",
    "#     o = tfsim.layers.ActivationStdLoggingLayer(name=\"proj_std\")(x)\n",
    "#     projector = tf.keras.Model(inputs, o, name=\"projector\")\n",
    "#     return projector\n",
    "\n",
    "# projector = get_projector(input_dim=backbone.output.shape[-1], dim=DIM, num_layers=2)\n",
    "# projector.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predictor model\n",
    "\n",
    "The predictor model is used by [BYOL](https://arxiv.org/abs/2006.07733) and [SimSiam](https://arxiv.org/abs/2011.10566), and is an additional 2 layer MLP containing a bottleneck in the hidden layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictor = None  # Passing None will automatically build the default predictor.\n",
    "\n",
    "# # Uncomment to build a custom predictor.\n",
    "# def get_predictor(input_dim, hidden_dim=512, activation=\"relu\"):\n",
    "#     inputs = tf.keras.layers.Input(shape=(input_dim,), name=\"predictor_input\")\n",
    "#     x = inputs\n",
    "\n",
    "#     x = tf.keras.layers.Dense(\n",
    "#         hidden_dim,\n",
    "#         use_bias=False,\n",
    "#         kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#         name=\"predictor_layer_0\",\n",
    "#     )(x)\n",
    "#     x = tf.keras.layers.BatchNormalization(epsilon=1.001e-5, name=\"batch_normalization_0\")(x)\n",
    "#     x = tf.keras.layers.Activation(activation, name=f\"{activation}_activation_0\")(x)\n",
    "\n",
    "#     x = tf.keras.layers.Dense(\n",
    "#         input_dim,\n",
    "#         kernel_initializer=tf.keras.initializers.LecunUniform(),\n",
    "#         name=\"predictor_output\",\n",
    "#     )(x)\n",
    "#     # Metric Logging layer. Monitors the std of the layer activations.\n",
    "#     # Degnerate solutions colapse to 0 while valid solutions will move\n",
    "#     # towards something like 0.0220. The actual number will depend on the layer size.\n",
    "#     o = tfsim.layers.ActivationStdLoggingLayer(name=\"pred_std\")(x)\n",
    "#     predictor = tf.keras.Model(inputs, o, name=\"predictor\")\n",
    "#     return predictor\n",
    "\n",
    "\n",
    "# predictor = get_predictor(input_dim=DIM, hidden_dim=512)\n",
    "# predictor.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Self-Supervised Algorithms\n",
    " \n",
    "The following section builds the `ContrastiveModel` based on the `ALGORITHM` set at the start of the Notebook.\n",
    " \n",
    "The model training is very sensitive to the learning rate decay and weight decay.\n",
    "* **SimSiam**: Requires using SGD with weight decay from TF Addons. Adding weight decay as a kernel_regularizer doesn't seem to be able to reproduce the published results in the paper.\n",
    "* **Barlow Twins**: We can use LAMB and avoid the need for the learning rate schedule. Lamb is similar to the LARS optimizer used in the Barlow paper, but includes the use of ADAM. Alternatively, we can use SGD but the optimizer requires a warm up period, otherwise the loss explodes.\n",
    "* **SimCLR**: We can also use LAMB as the original paper uses LARS. However, LAMB seems to require smaller learning rates than shown for LARS in the original paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model = tfsim.models.create_contrastive_model(\n",
    "    backbone=backbone,\n",
    "    projector=projector,\n",
    "    predictor=predictor,\n",
    "    algorithm=ALGORITHM,\n",
    "    name=ALGORITHM,\n",
    ")\n",
    "\n",
    "if ALGORITHM == \"simsiam\":\n",
    "    loss = tfsim_losses.SimSiamLoss(projection_type=\"cosine_distance\", name=ALGORITHM)\n",
    "    lr_decayed_fn = tf.keras.optimizers.schedules.CosineDecay(\n",
    "        initial_learning_rate=INIT_LR,\n",
    "        decay_steps=PRE_TRAIN_EPOCHS * PRE_TRAIN_STEPS_PER_EPOCH,\n",
    "    )\n",
    "    wd_decayed_fn = tf.keras.optimizers.schedules.CosineDecay(\n",
    "        initial_learning_rate=WEIGHT_DECAY,\n",
    "        decay_steps=PRE_TRAIN_EPOCHS * PRE_TRAIN_STEPS_PER_EPOCH,\n",
    "    )\n",
    "    optimizer = tfa.optimizers.SGDW(learning_rate=lr_decayed_fn, weight_decay=wd_decayed_fn, momentum=0.9)\n",
    "elif ALGORITHM == \"barlow\":\n",
    "    loss = tfsim_losses.Barlow(name=ALGORITHM)\n",
    "    optimizer = tfa.optimizers.LAMB(learning_rate=INIT_LR)\n",
    "elif ALGORITHM == \"simclr\":\n",
    "    loss = tfsim_losses.SimCLRLoss(name=ALGORITHM, temperature=TEMPERATURE)\n",
    "    optimizer = tfa.optimizers.LAMB(learning_rate=INIT_LR)\n",
    "elif ALGORITHM == \"vicreg\":\n",
    "    loss = tfsim_losses.VicReg(name=ALGORITHM)\n",
    "    optimizer = tfa.optimizers.LAMB(learning_rate=INIT_LR)\n",
    "else:\n",
    "    raise ValueError(f\"{ALGORITHM} is not supported.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model.compile(\n",
    "    optimizer=optimizer,\n",
    "    loss=loss,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Callbacks\n",
    "\n",
    "We track the training using several callbacks.\n",
    "\n",
    "* **EvalCallback** creates an index at the end of each epoch and provides a proxy for the nearest neighbor matching classification using `binary_accuracy`.\n",
    "* **TensordBoard** and **ModelCheckpoint** are provided for tracking the training progress."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TensorBoard logging enable in tfsim_contrastive_model/models/logs/simsiam_1693860062.8812578/index\n"
     ]
    }
   ],
   "source": [
    "log_dir = DATA_PATH / \"models\" / \"logs\" / f\"{loss.name}_{time.time()}\"\n",
    "chkpt_dir = DATA_PATH / \"models\" / \"checkpoints\" / f\"{loss.name}_{time.time()}\"\n",
    "\n",
    "\n",
    "evb = tfsim_callbacks.EvalCallback(\n",
    "    img_scaling(tf.cast(x_query, tf.float32)),\n",
    "    y_query,\n",
    "    img_scaling(tf.cast(x_index, tf.float32)),\n",
    "    y_index,\n",
    "    metrics=[\"binary_accuracy\"],\n",
    "    k=1,\n",
    "    tb_logdir=log_dir,\n",
    ")\n",
    "tbc = tf.keras.callbacks.TensorBoard(\n",
    "    log_dir=log_dir,\n",
    "    histogram_freq=1,\n",
    "    update_freq=100,\n",
    ")\n",
    "mcp = tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath=chkpt_dir,\n",
    "    monitor=\"val_loss\",\n",
    "    mode=\"min\",\n",
    "    save_best_only=True,\n",
    "    save_weights_only=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Model Training\n",
    " \n",
    "The model training provides a number of metrics.\n",
    "- **loss**: This represents the total loss over the contrastive batch. Separate contrastive and regularization losses will also be shown if there are trainable variables in the model layers.\n",
    "- **proj_std and pred_std**: These are added as metric logging layers in the model and show the std of the activations of the final layer in the projector or predictor models.\n",
    "- **binary_accuracy**: This is the nearest neighbor matching classification accuracy. A new index is built at the end of each epoch and the accuracy is computed using the query and index examples.\n",
    " \n",
    "**Notes: Move this to the evaluation section in the paper.**\n",
    "- SGDW or LAMB seems to be required to prevent the loss from becoming unstable.\n",
    "- Per layer kernel_regularization with weight decay doesn't work.\n",
    "- The kernel initialization seems very critical. Smaller, uniform initialization schemes like Lecunn seem to work best.\n",
    "- The projector is a more stable output for the KNN match metrics. The predictor output is typically worse and higher variance.\n",
    "- The LR and weight decay schedule seem important. The loss becomes unstable if the updates are too large later in training.\n",
    "- Too much capacity in the combined model and the training won't converge... same goes for too little capacity.\n",
    "- Augmentation is critical, but too much augmentation and the model won't converge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/800\n",
      "87/87 [==============================] - 39s 306ms/step - loss: 0.4571 - projector_loss: 0.2286 - proj_std: 0.0361 - pred_std: 0.0278 - val_loss: 0.2085 - val_projector_loss: 0.1043 - val_proj_std: 0.0244 - val_pred_std: 0.0192 - binary_accuracy: 0.2440\n",
      "Epoch 2/800\n",
      "87/87 [==============================] - 23s 266ms/step - loss: 0.3405 - projector_loss: 0.1702 - proj_std: 0.0412 - pred_std: 0.0383 - val_loss: 0.0860 - val_projector_loss: 0.0430 - val_proj_std: 0.0181 - val_pred_std: 0.0146 - binary_accuracy: 0.2145\n",
      "Epoch 3/800\n",
      "87/87 [==============================] - 23s 264ms/step - loss: 0.2814 - projector_loss: 0.1407 - proj_std: 0.0423 - pred_std: 0.0411 - val_loss: 0.0904 - val_projector_loss: 0.0452 - val_proj_std: 0.0218 - val_pred_std: 0.0193 - binary_accuracy: 0.2150\n",
      "...\n",
      "Epoch 798/800\n",
      "87/87 [==============================] - 23s 263ms/step - loss: 0.0530 - projector_loss: 0.0265 - proj_std: 0.0436 - pred_std: 0.0436 - val_loss: 0.1290 - val_projector_loss: 0.0645 - val_proj_std: 0.0436 - val_pred_std: 0.0436 - binary_accuracy: 0.8345\n",
      "Epoch 799/800\n",
      "87/87 [==============================] - 23s 267ms/step - loss: 0.0525 - projector_loss: 0.0263 - proj_std: 0.0436 - pred_std: 0.0436 - val_loss: 0.1311 - val_projector_loss: 0.0656 - val_proj_std: 0.0436 - val_pred_std: 0.0436 - binary_accuracy: 0.8345\n",
      "Epoch 800/800\n",
      "87/87 [==============================] - 23s 263ms/step - loss: 0.0534 - projector_loss: 0.0267 - proj_std: 0.0436 - pred_std: 0.0436 - val_loss: 0.1334 - val_projector_loss: 0.0667 - val_proj_std: 0.0436 - val_pred_std: 0.0436 - binary_accuracy: 0.8330\n"
     ]
    }
   ],
   "source": [
    "history = contrastive_model.fit(\n",
    "    train_ds,\n",
    "    epochs=PRE_TRAIN_EPOCHS,\n",
    "    steps_per_epoch=PRE_TRAIN_STEPS_PER_EPOCH,\n",
    "    validation_data=val_ds,\n",
    "    validation_steps=VAL_STEPS_PER_EPOCH,\n",
    "    callbacks=[evb, tbc, mcp],\n",
    "    verbose=1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1500x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15, 4))\n",
    "plt.subplot(1, 3, 1)\n",
    "plt.plot(history.history[\"loss\"])\n",
    "plt.grid()\n",
    "plt.title(f\"{loss.name} - loss\")\n",
    "\n",
    "plt.subplot(1, 3, 2)\n",
    "plt.plot(history.history[\"proj_std\"], label=\"proj\")\n",
    "if \"pred_std\" in history.history:\n",
    "    plt.plot(history.history[\"pred_std\"], label=\"pred\")\n",
    "plt.grid()\n",
    "plt.title(f\"{loss.name} - std metrics\")\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(1, 3, 3)\n",
    "plt.plot(history.history[\"binary_accuracy\"], label=\"acc\")\n",
    "plt.grid()\n",
    "plt.title(f\"{loss.name} - match metrics\")\n",
    "plt.legend()\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save and Reload\n",
    " \n",
    "The `ContrastiveModel` contains a set of sub-models and custom train and test steps. Consequently, the `ContrastiveModel` implements a custom save function that performs the following:\n",
    "* Saves each of the sub models, including the predictor if one exists.\n",
    "* A JSON file containing the serialized Loss, Metrics, and Optimizer.\n",
    "* The Optimizer weighs as a npy file.\n",
    " \n",
    "We also provide a custom `load_model()` function that restores the `ContrastiveModel` and supports continued training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can also load the trained weights from the model checkpoints\n",
    "# contrastive_model.load_weights(DATA_PATH / 'models' / 'checkpoints' / f\"{loss.name}_{CHECKPOINT_TIMESTAMP}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 21). These functions will not be directly callable after loading.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: tfsim_contrastive_model/models/trained_model/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: tfsim_contrastive_model/models/trained_model/assets\n"
     ]
    }
   ],
   "source": [
    "contrastive_model.save(DATA_PATH / \"models\" / \"trained_model\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "del contrastive_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "contrastive_model = tf.keras.models.load_model(\n",
    "    DATA_PATH / \"models\" / \"trained_model\",\n",
    "    custom_objects={\n",
    "        \"ContrastiveModel\": tfsim.models.ContrastiveModel,\n",
    "        \"ActivationStdLoggingLayer\": tfsim.layers.ActivationStdLoggingLayer,\n",
    "    },\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Evaluation\n",
    " \n",
    "This final section trains two different classifiers.\n",
    " \n",
    "1. **No Pre-training**: Uses a ResNet18 model and a simple linear layer.\n",
    " \n",
    "2. **Pre-trained** Uses the frozen pre-trained backbone from the ContrastiveModel and only trains the weights in the linear layer.\n",
    " \n",
    "The original train data is partitioned into eval_train and eval_val splits and a simplified augmentation is applied to the training data. \n",
    " \n",
    "The models are then trained for 10 epochs and the classification accuracy is evaluated on the held out test split."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "TEST_EPOCHS = 10\n",
    "TEST_STEPS_PER_EPOCH = len(x_train) // BATCH_SIZE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "@tf.function\n",
    "def eval_augmenter(img):\n",
    "    # random resize and crop. Increase the size before we crop.\n",
    "    img = tfsim.augmenters.augmentation_utils.cropping.crop_and_resize(\n",
    "        img, CIFAR_IMG_SIZE, CIFAR_IMG_SIZE, area_range=(0.2, 1.0)\n",
    "    )\n",
    "    # random horizontal flip\n",
    "    img = tf.image.random_flip_left_right(img)\n",
    "    img = tf.clip_by_value(img, 0.0, 255.0)\n",
    "\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "eval_train_ds = tf.data.Dataset.from_tensor_slices((x_train, tf.keras.utils.to_categorical(y_train, 10)))\n",
    "eval_train_ds = eval_train_ds.repeat()\n",
    "eval_train_ds = eval_train_ds.shuffle(1024)\n",
    "eval_train_ds = eval_train_ds.map(lambda x, y: (eval_augmenter(x), y), tf.data.AUTOTUNE)\n",
    "eval_train_ds = eval_train_ds.map(lambda x, y: (img_scaling(x), y), tf.data.AUTOTUNE)\n",
    "eval_train_ds = eval_train_ds.batch(BATCH_SIZE)\n",
    "eval_train_ds = eval_train_ds.prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "eval_val_ds = tf.data.Dataset.from_tensor_slices((x_val, tf.keras.utils.to_categorical(y_val, 10)))\n",
    "eval_val_ds = eval_val_ds.repeat()\n",
    "eval_val_ds = eval_val_ds.shuffle(1024)\n",
    "eval_val_ds = eval_val_ds.map(lambda x, y: (img_scaling(tf.cast(x, dtype=tf.float32)), y), tf.data.AUTOTUNE)\n",
    "eval_val_ds = eval_val_ds.batch(BATCH_SIZE)\n",
    "eval_val_ds = eval_val_ds.prefetch(tf.data.AUTOTUNE)\n",
    "\n",
    "eval_test_ds = tf.data.Dataset.from_tensor_slices((x_test, tf.keras.utils.to_categorical(y_test, 10)))\n",
    "eval_test_ds = eval_test_ds.map(lambda x, y: (img_scaling(tf.cast(x, dtype=tf.float32)), y), tf.data.AUTOTUNE)\n",
    "eval_test_ds = eval_test_ds.batch(BATCH_SIZE)\n",
    "eval_test_ds = eval_test_ds.prefetch(tf.data.AUTOTUNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_eval_model(img_size, backbone, total_steps, trainable=True, lr=1.8):\n",
    "    backbone.trainable = trainable\n",
    "    inputs = tf.keras.layers.Input((img_size, img_size, 3), name=\"eval_input\")\n",
    "    x = backbone(inputs, training=trainable)\n",
    "    o = tf.keras.layers.Dense(10, activation=\"softmax\")(x)\n",
    "    model = tf.keras.Model(inputs, o)\n",
    "    cosine_decayed_lr = tf.keras.experimental.CosineDecay(initial_learning_rate=lr, decay_steps=total_steps)\n",
    "    opt = tf.keras.optimizers.SGD(cosine_decayed_lr, momentum=0.9)\n",
    "    model.compile(optimizer=opt, loss=\"categorical_crossentropy\", metrics=[\"acc\"])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### No Pretrain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "87/87 [==============================] - 16s 122ms/step - loss: 2.0544 - acc: 0.2500 - val_loss: 1.7642 - val_acc: 0.3419\n",
      "Epoch 2/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.7441 - acc: 0.3552 - val_loss: 1.6110 - val_acc: 0.4074\n",
      "Epoch 3/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.6547 - acc: 0.3944 - val_loss: 1.5366 - val_acc: 0.4442\n",
      "Epoch 4/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.5939 - acc: 0.4155 - val_loss: 1.4864 - val_acc: 0.4617\n",
      "Epoch 5/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.5614 - acc: 0.4321 - val_loss: 1.4571 - val_acc: 0.4718\n",
      "Epoch 6/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.5240 - acc: 0.4458 - val_loss: 1.4293 - val_acc: 0.4889\n",
      "Epoch 7/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.5053 - acc: 0.4535 - val_loss: 1.4216 - val_acc: 0.4894\n",
      "Epoch 8/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.4906 - acc: 0.4617 - val_loss: 1.4144 - val_acc: 0.4902\n",
      "Epoch 9/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.4882 - acc: 0.4609 - val_loss: 1.4100 - val_acc: 0.4878\n",
      "Epoch 10/10\n",
      "87/87 [==============================] - 10s 114ms/step - loss: 1.4878 - acc: 0.4614 - val_loss: 1.4091 - val_acc: 0.4876\n"
     ]
    }
   ],
   "source": [
    "no_pt_eval_model = get_eval_model(\n",
    "    img_size=CIFAR_IMG_SIZE,\n",
    "    backbone=get_backbone(CIFAR_IMG_SIZE, DIM),\n",
    "    total_steps=TEST_EPOCHS * TEST_STEPS_PER_EPOCH,\n",
    "    trainable=True,\n",
    "    lr=1e-3,\n",
    ")\n",
    "no_pt_history = no_pt_eval_model.fit(\n",
    "    eval_train_ds,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    epochs=TEST_EPOCHS,\n",
    "    steps_per_epoch=TEST_STEPS_PER_EPOCH,\n",
    "    validation_data=eval_val_ds,\n",
    "    validation_steps=VAL_STEPS_PER_EPOCH,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pretrained"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_1\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " eval_input (InputLayer)     [(None, 32, 32, 3)]       0         \n",
      "                                                                 \n",
      " resnet18sim (SimilarityMode  (None, 512)              11182784  \n",
      " l)                                                              \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 10)                5130      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 11,187,914\n",
      "Trainable params: 5,130\n",
      "Non-trainable params: 11,182,784\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "pt_eval_model = get_eval_model(\n",
    "    img_size=CIFAR_IMG_SIZE,\n",
    "    backbone=contrastive_model.backbone,\n",
    "    total_steps=TEST_EPOCHS * TEST_STEPS_PER_EPOCH,\n",
    "    trainable=False,\n",
    "    lr=30.0,\n",
    ")\n",
    "pt_eval_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "87/87 [==============================] - 3s 23ms/step - loss: 35.6107 - acc: 0.1030 - val_loss: 25.4701 - val_acc: 0.0993\n",
      "Epoch 2/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 32.7061 - acc: 0.1237 - val_loss: 30.5208 - val_acc: 0.0986\n",
      "Epoch 3/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 32.7497 - acc: 0.1418 - val_loss: 27.5788 - val_acc: 0.1004\n",
      "Epoch 4/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 16.5545 - acc: 0.2016 - val_loss: 8.6349 - val_acc: 0.2104\n",
      "Epoch 5/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 2.4286 - acc: 0.6884 - val_loss: 0.4192 - val_acc: 0.8711\n",
      "Epoch 6/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 0.3943 - acc: 0.8763 - val_loss: 0.3996 - val_acc: 0.8714\n",
      "Epoch 7/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 0.3866 - acc: 0.8797 - val_loss: 0.4010 - val_acc: 0.8761\n",
      "Epoch 8/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 0.3789 - acc: 0.8813 - val_loss: 0.4001 - val_acc: 0.8798\n",
      "Epoch 9/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 0.3724 - acc: 0.8837 - val_loss: 0.3952 - val_acc: 0.8747\n",
      "Epoch 10/10\n",
      "87/87 [==============================] - 2s 21ms/step - loss: 0.3729 - acc: 0.8832 - val_loss: 0.3944 - val_acc: 0.8809\n"
     ]
    }
   ],
   "source": [
    "pt_history = pt_eval_model.fit(\n",
    "    eval_train_ds,\n",
    "    batch_size=BATCH_SIZE,\n",
    "    epochs=TEST_EPOCHS,\n",
    "    steps_per_epoch=TEST_STEPS_PER_EPOCH,\n",
    "    validation_data=eval_val_ds,\n",
    "    validation_steps=VAL_STEPS_PER_EPOCH,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20/20 [==============================] - 1s 41ms/step - loss: 1.3810 - acc: 0.4995\n",
      "no pretrain [1.3809714317321777, 0.49950000643730164]\n",
      "20/20 [==============================] - 0s 17ms/step - loss: 0.4113 - acc: 0.8748\n",
      "pretrained [0.41125455498695374, 0.8748000264167786]\n"
     ]
    }
   ],
   "source": [
    "print(\"no pretrain\", no_pt_eval_model.evaluate(eval_test_ds))\n",
    "print(\"pretrained\", pt_eval_model.evaluate(eval_test_ds))"
   ]
  }
 ],
 "metadata": {
  "environment": {
   "kernel": "python3",
   "name": "tf2-gpu.2-8.m91",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-8:m91"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "c7b3389fe492617a9dd862ce9e69c0dfb3e62254a4be8ff5561f4f9b5c78139c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
